/* serie2.c
Une base d'implémentation pour un SOM.
Le programme ne contient pas de fonction d'apprentissage mais construit un réseau de neurones avec des poids aléatoires, et des vecteurs d'apprentissage également crées aléatoirement.
Modification du programme pour le parcours aléatoire : simplification par l'algorithme de Fisher-Yates ( = Knuth shuffle)
Roxane Levy
*/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <mysql.h>
#include <math.h>


typedef struct Data Data ;   // pour les données d'apprentissage
struct Data {
	int N_L_input_V ;   // le nombre de vecteurs d'apprentissage
	int N ;             // la taille des vecteurs d'apprentissage
	float ** vecApprentissage ;   //la matrice N_L_input_V * N contenant les vecteurs d'apprentissage
} ;



typedef struct Net Net ;    // la map de Kohonen
struct Net {
   	float * captr ;       // input layer, reçoit le vecteur d'apprentissage
	int map_x,map_y ;        ; // dimension du réseau (largeur et longueur de la map)
	int neuroneSize ;   //équivalent à la taille des vecteurs d'apprentissage
	float *** RN  ;  // contient les neurones, soit une matrice map_x * map_y vecteurs de même taille que les vecteurs d'apprentissage ( = neuroneSize)
	float ** activation_map ;    //une matrice pour contenir l'état d'activation des neurones
	float ** g ; //  une matrice pour la fonction de voisinage
    	int bmuCoord[1] ;   // pour contenir les coordonnées du bmu
	
};



typedef struct Options Options;
struct Options {
	int flagshuffle ;   // contrôle le chargement séquentiel ou désordonné
	int nb_iter ;   // le nombre d'itérations
	float sigma ;
} ;


/************** PROTOYPES DES FONCTIONS ************************/
void initialiseDatafromDatabase(Data * data) ;
void initialiseRNandMore(Net * net) ; //including activation map
void initialiseRN(Net * net) ;
float normeVec(float vector[],int x) ;
void findbestmatchingnode(Net * net) ;
float euclidian(float vectorMap[], float vectorData[], int sizeVec)  ;
void smallestvalue(Net * net) ;
void afficheActivationMap(Net *net) ;
float normeVec(float vec[] , int vectorSize) ;
void normalizeData(Data * data) ;
void normalizeRN(Net * net) ;
void update(Net * net, Options * options,int iteration) ;
void affiche_vecteurint(int vector[], int tailleVecteur) ;
float * substractArrayandMultiply(float array1[], float array2[], int sizeArray, float multiplier) ;
void addArray(float array1[], float array2[], int sizeArray)  ;

void initialiseRandomly() ;
float float_aleatoire_borne (float min, float max) ;
void genereVec(float * vec, int size) ;
void destroyRN() ;
void destroyRNandMore() ;
void afficheRN() ;
void affiche_vecteur(float vector[], int tailleVecteur) ;
void destroyData () ;
void afficheData();
void input_sequence() ;
void input_random(Data * data, Net * net, Options * options)  ;
int int_aleatoire(void) ;
int int_aleatoire_borne(int max) ;
void shuffleVec(int sourceVecteur[], int tailleVecteur) ;   // la fonction pour la permutation aléatoire

